<?php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006~2019 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: liu21st <liu21st@gmail.com>
// +----------------------------------------------------------------------
declare (strict_types = 1); //声明代码的执行指令为开启严格模式,主要为参数类型为严格模式,方便常驻内存

namespace think;

use ArrayAccess;
use ArrayIterator;
use Closure;
use Countable;
use InvalidArgumentException;
use IteratorAggregate;
use Psr\Container\ContainerInterface;
use ReflectionClass;
use ReflectionException;
use ReflectionFunction;
use ReflectionFunctionAbstract;
use ReflectionMethod;
use think\exception\ClassNotFoundException;
use think\exception\FuncNotFoundException;
use think\helper\Str;


// +----------------------------------------------------------------------
// |
// | (愿景,目的) 所属:基础核心
// | (功能) 名称: 容器管理类
// | (心智)原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
// | (结构/形式) 类模式: 多重继承
// | (模式)模式类型: 创造类
// | (模式)设计模式: 工厂模式
// | 产生事件:
// | Understand:Cluster | Cluster Call Butterfly
// |
// | ---------分析--------------
// | 需求的产生 想法
// | 道: <用户-客户立场>|<人的视角>(欲望)
// | 愿景: 基于容器模式的框架
// | 目的: 充分使用 控制反转和依赖注入
// |
// | =============================
// | 需求的分解--架构-偏商业架构/业务角度
// | 法: <组织内部立场>|<人的视角>
// | 目的: 遵循规范标准 PSR
// | 心智:遵循思维模式,原则
// | (系统)功能:
// | 结构:
// | 协议:
// |
// | =============================
// | 不同环境下的适应性,范围越大越优雅,TP 在复杂应用环境下对领域边界的处理不够,
// | 照成项目文件的复杂错乱,不易迭代,是导致被鄙视的根源
// | 需求点规划/-架构-技术架构,开发上这块是核心 做法
// | 术:<组织内部立场>|<物的视角>
// | 用户/客户立场:(人的视角)(结果)感知
// | 形式:
// |
// | 组织内部立场:(物的视角)(设定)系统思考.逻辑思考
// | 结构:
// |
// | =============================
// | 方案实施 执行 怎么用
// | 器:<物的视角>
// | (转换接口,把物和人联系起来)
// | 形式:
// |
// | (用户/客户立场|视角|(背后是结构)
// | 模式:
// |
// | (具体方法)
// | 事件:
// | -------------------------
// |
// | 知识点:  https://www.cnblogs.com/jiangxiaobo/p/9607867.html
// | 参见: https://learnku.com/docs/psr
// | 继承类说明:
// | ContainerInterface 容器接口规范
// | ArrayAccess 对象以数组形式来使用
// | IteratorAggregate 聚合式迭代器，它提供了创建外部迭代器的接口.
// |                   ArrayIterator迭代器会把对象或数组封装为一个可以通过foreach来操作的类
// | Countable 继承Countable接口的可被用于count() 函数
// | 点评: 框架的核心部分,使用容器方式,实现.进程隔离,为常驻内存做好了准备
// | 使用接口方式多重继承 其他类
// |
// +----------------------------------------------------------------------

/**
 * 容器管理类 支持PSR-11
 */
class Container implements ContainerInterface, ArrayAccess, IteratorAggregate, Countable
{
    /**
     * 容器对象实例
     * @var Container|Closure
     */
    protected static $instance;

    /**
     * 容器中的对象实例
     * @var array
     */
    protected $instances = [];

    /**
     * 容器绑定标识
     * 该标识会被继承
     * @var array
     */
    protected $bind = [];

    /**
     * 容器回调
     * @var array
     */
    protected $invokeCallback = [];

    /**
     * 获取当前容器的实例（单例）
     * @depreacate 星级:***
     * @depreacate 作用:实现,数据
     * @todo 这个主要是给别的类用的,属于快捷操作,是怎么获取的.获取的什么.不明白,这个地方应该只是获取.没别的内容.最多获取一个空的对象,但作用?
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:1 无上级调用但有下级子调用
     *
     * @access public
     * @return static
     */
    public static function getInstance()
    {
        // 判断 容器中的对象实例
        if (is_null(static::$instance)) {
            static::$instance = new static;
        }

        if (static::$instance instanceof Closure) {
            return (static::$instance)();
        }

        return static::$instance;
    }

    /**
     * 设置当前容器的实例
     * @depreacate 星级:***
     * @depreacate 作用:实现,数据
     * @todo 这个主要是给别的类用的,属于快捷操作
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:1 无上级调用但有下级子调用
     *
     * @access public
     * @param object|Closure $instance
     * @return void
     */
    public static function setInstance($instance): void
    {
        // 容器对象实例
        // 为什么可以设置.原理是什么? 这个地方是核心
        // 这里在我看来,这个地方设置的,其实是一个表.把某个对象 设置到表里.
        static::$instance = $instance;
    }

    /**
     * 注册一个容器对象回调
     * @depreacate 星级:
     * @depreacate 作用:实现,逻辑,数据
     * @todo 
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:1 无上级调用但有下级子调用
     *
     * @param string|Closure $abstract 类名或者标识
     * @param Closure|null   $callback 回调匿名函数
     * @return void
     */
    public function resolving($abstract, Closure $callback = null): void
    {
        //
        if ($abstract instanceof Closure) {
            $this->invokeCallback['*'][] = $abstract;
            return;
        }

        // 根据别名获取真实类名
        $abstract = $this->getAlias($abstract);

        // 在容器回调数组中注册一个回调
        $this->invokeCallback[$abstract][] = $callback;
    }

    /**
     * 获取容器中的对象实例 不存在则创建
     * @depreacate 星级:***
     * @depreacate 作用:调度,别名
     * @todo 这个主要是给别的类用的,属于快捷操作
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:1 无上级调用但有下级子调用
     *
     * @access public
     * @param string     $abstract    类名或者标识
     * @param array|true $vars        变量
     * @param bool       $newInstance 是否每次创建新的实例
     * @return object
     */
    public static function pull(string $abstract, array $vars = [], bool $newInstance = false)
    {
        // 获取当前容器的实例（单例）后创建类的实例
        return static::getInstance()->make($abstract, $vars, $newInstance);
    }

    /**
     * 获取容器中的对象实例
     * @depreacate 星级:***
     * @depreacate 作用:逻辑/调度
     * @todo 
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:1 无上级调用但有下级子调用
     *
     * @access public
     * @param string $abstract 类名或者标识
     * @return object
     */
    public function get($abstract)
    {
        // 判断容器中是否存在类及标识
        if ($this->has($abstract)) {
            // 创建类的实例
            return $this->make($abstract);
        }

        // 类未找到错误异常,对象获取的时候很容易发生这样的情况,所以需要捕获
        throw new ClassNotFoundException('class not exists: ' . $abstract, $abstract);
    }

    /**
     * 绑定一个类、闭包、实例、接口实现到容器
     * @depreacate 星级:***
     * @depreacate 作用:逻辑/数据
     * @todo 实际的作用就是对容器绑定标识数组的操作
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:1 无上级调用但有下级子调用
     *
     * @access public
     * @param string|array $abstract 类标识、接口
     * @param mixed        $concrete 要绑定的类、闭包或者实例
     * @return $this
     */
    public function bind($abstract, $concrete = null)
    {
        // 绑定了后,如何用?

        // 判断不同类型,进行加载
        if (is_array($abstract)) {
            // 数组,其实是定义配置.需要递归调用自己再次加载
            foreach ($abstract as $key => $val) {
                $this->bind($key, $val);
            }
        } elseif ($concrete instanceof Closure) {
            // 闭包,写入容器绑定标识数组
            // 判断是否属于某个类的匿名函数引用
            $this->bind[$abstract] = $concrete;
        } elseif (is_object($concrete)) {
            // 如果是对象,绑定一个类实例到容器
            // 这个处理是真有用的处理
            $this->instance($abstract, $concrete);
        } else {
            // 对重复绑定的处理,返回之前已经绑定过的,然后覆盖掉
            // 过往定义过的
            $abstract = $this->getAlias($abstract);
            if ($abstract != $concrete) {
                $this->bind[$abstract] = $concrete;
            }
        }

        return $this;
    }

    /**
     * 根据别名获取真实类名
     * @depreacate 星级:***
     * @depreacate 作用:数据
     * @todo 原子调用,通过判断是否是实例对象来判断别名查询是否是正确的,来分红别名
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:3 有上级调用但无下级调用
     * 关联直接源:self::bind()
     *
     * @param  string $abstract 类标识、接口
     * @return string
     */
    public function getAlias(string $abstract): string
    {
        // 定义过的,都会存在一个数组.引用的数组.
        // 通过判断容器绑定标识中是否存在来返回真实的类名
        if (isset($this->bind[$abstract])) {
            // 正常返回的应该是非字符的一个对象
            $bind = $this->bind[$abstract];

            // 这个是什么意思?为什么是字符串的时候,还要递归自己?
            // 为什么会返回字符串?
            if (is_string($bind)) {
                return $this->getAlias($bind);
            }
        }

        // 对于没有预定义过的.返回原名.所以这个标志必须写正确了.
        return $abstract;
    }

    /**
     * 绑定一个类实例到容器
     * @depreacate 星级:****
     * @depreacate 作用:数据
     * @todo 其实就是建立数组来维护实例里创建的对象,但这个的实现原理是什么?可能是从比如继承的子类 app 的容器绑定对象中,绑定一个对象
     * @depreacate 原则:依赖倒置原则/接口隔离原则/开闭原则
     * @depreacate 调用级别:3 有上级调用但无下级调用
     *
     * @access public
     * @param string $abstract 类名或者标识
     * @param object $instance 类的实例
     * @return $this
     */
    public function instance(string $abstract, $instance)
    {
        // 什么叫绑定一个类实例到容器
        // 其实就是建立 对象 别名 数组列表.以便在容器中使用. 方便索引到对应的类
        // 根据别名获取真实类名
        $abstract = $this->getAlias($abstract);

        // 通过获取实例中,容器中的对象实例
        $this->instances[$abstract] = $instance;

        return $this;
    }

    /**
     * 判断容器中是否存在类及标识
     * @depreacate 星级:
     * @depreacate 作用:实现
     * @todo 
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:3 有上级调用但无下级调用
     *
     * @access public
     * @param string $abstract 类名或者标识
     * @return bool
     */
    public function bound(string $abstract): bool
    {
        return isset($this->bind[$abstract]) || isset($this->instances[$abstract]);
    }

    /**
     * 判断容器中是否存在类及标识
     * @depreacate 星级:
     * @depreacate 作用:别名
     * @todo 
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:2 有上级调用也有下级调用
     *
     * @access public
     * @param string $name 类名或者标识
     * @return bool
     */
    public function has($name): bool
    {
        // 判断容器中是否存在类及标识
        return $this->bound($name);
    }

    /**
     * 判断容器中是否存在对象实例
     * @depreacate 星级:
     * @depreacate 作用:实现
     * @todo 
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:2 有上级调用也有下级调用
     *
     * @access public
     * @param string $abstract 类名或者标识
     * @return bool
     */
    public function exists(string $abstract): bool
    {
        // 根据别名获取真实类名
        $abstract = $this->getAlias($abstract);

        // 检测在容器中的对象实例是否已经存在
        return isset($this->instances[$abstract]);
    }

    /**
     * 创建类的实例 已经存在则直接获取
     * @depreacate 星级:*****
     * @depreacate 作用:调度
     * @todo 核心的调用方法,外部调用容器基本都是调用本方法
     *      返回创建的对象,其实就是返回创建的对象内存寻址值
     *      分析实例的几种可能情况,分别返回
     * @depreacate 原则:单一职责原则/依赖倒置原则/开闭原则
     * @depreacate 调用级别:2 有上级调用也有下级调用
     *
     * @access public
     * @param string $abstract    类名或者标识
     * @param array  $vars        变量
     * @param bool   $newInstance 是否每次创建新的实例
     * @return mixed
     */
    public function make(string $abstract, array $vars = [], bool $newInstance = false)
    {
        // 根据别名获取真实类名
        $abstract = $this->getAlias($abstract);

        // 检测在容器中的对象实例是否已经存在
        if (isset($this->instances[$abstract]) && !$newInstance) {
            return $this->instances[$abstract];
        }

        // 通过名字去实例化类.所以必须建立对应的绑定容器数组
        // 判断容器绑定标识中是否存在 &&  是否是匿名函数 是否用于代表 匿名函数 的类
        if (isset($this->bind[$abstract]) && $this->bind[$abstract] instanceof Closure) {
            // 执行函数或者闭包方法
            $object = $this->invokeFunction($this->bind[$abstract], $vars);
        } else {
            // 调用反射执行类的实例化
            $object = $this->invokeClass($abstract, $vars);
        }

        // 如果不是创建新的实例.就更新已经创建过的对应对象
        if (!$newInstance) {
            $this->instances[$abstract] = $object;
        }

        // 返回对象
        return $object;
    }

    /**
     * 删除容器中的对象实例
     * @depreacate 星级:
     * @depreacate 作用:实现
     * @todo 
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:2 有上级调用也有下级调用
     *
     * @access public
     * @param string $name 类名或者标识
     * @return void
     */
    public function delete($name)
    {
        // 根据别名获取真实类名
        $name = $this->getAlias($name);

        // 删除容器中的对象实例
        if (isset($this->instances[$name])) {
            unset($this->instances[$name]);
        }
    }

    /**
     * 执行函数或者闭包方法 支持参数调用
     * @depreacate 星级:*****
     * @depreacate 作用:实现,逻辑
     * @todo 
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:2 有上级调用也有下级调用
     *
     * @access public
     * @param string|Closure $function 函数或者闭包
     * @param array          $vars     参数
     * @return mixed
     */
    public function invokeFunction($function, array $vars = [])
    {
        // 因为函数调用容易出现异常,因此加上异常捕获
        try {
            // 获取实例中的函数反射,因为系统加载时已经全部注册了
            // 如果获取不到.就是出错了.代表函数不存在
            // 返回的结果是反射信息
            $reflect = new ReflectionFunction($function);
        } catch (ReflectionException $e) {
            throw new FuncNotFoundException("function not exists: {$function}()", $function, $e);
        }

        // 绑定参数?为什么要这样获取参数
        // 感觉是要对参数进行清洗,以符合反射类
        $args = $this->bindParams($reflect, $vars);

        // 经过严格检查后,才能调用方法
        return $function(...$args);
    }

    /**
     * 调用反射执行类的方法 支持参数绑定
     * @depreacate 星级:*****
     * @depreacate 作用:实现,逻辑
     * @todo 
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:2 有上级调用也有下级调用
     *
     * @access public
     * @param mixed $method     方法
     * @param array $vars       参数
     * @param bool  $accessible 设置是否可访问
     * @return mixed
     */
    public function invokeMethod($method, array $vars = [], bool $accessible = false)
    {
        if (is_array($method)) {
            // 把数组里的值赋值给对应的变量
            [$class, $method] = $method;

            // 如果是对象直接调用,否则先去调用反射执行类的实例化
            $class = is_object($class) ? $class : $this->invokeClass($class);
        } else {
            // 注意:tp 中.静态方法得写成::比较好
            // 静态方法
            [$class, $method] = explode('::', $method);
        }

        // 因为方法调用容易出现异常,因此加上异常捕获
        try {
            // 获取实例中指定类中的反射,因为系统加载时已经全部注册了
            $reflect = new ReflectionMethod($class, $method);
        } catch (ReflectionException $e) {
            $class = is_object($class) ? get_class($class) : $class;
            throw new FuncNotFoundException('method not exists: ' . $class . '::' . $method . '()', "{$class}::{$method}", $e);
        }

        // 绑定参数?为什么要这样获取参数
        // 感觉是要对参数进行清洗,以符合反射类
        $args = $this->bindParams($reflect, $vars);

        // 如果可以访问
        if ($accessible) {
            // 设置方法是否可以访问，例如通过设置可以访问能够执行私有方法和保护方法
            $reflect->setAccessible($accessible);
        }

        // 使用数组给方法传送参数,并执行。
        return $reflect->invokeArgs(is_object($class) ? $class : null, $args);
    }

    /**
     * 调用反射执行类的方法 支持参数绑定
     * @depreacate 星级:
     * @depreacate 作用:实现,逻辑
     * @todo 
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:1 无上级调用但有下级子调用
     *
     * @access public
     * @param object $instance 对象实例
     * @param mixed  $reflect  反射类
     * @param array  $vars     参数
     * @return mixed
     */
    public function invokeReflectMethod($instance, $reflect, array $vars = [])
    {
        // 绑定参数?为什么要这样获取参数
        // 感觉是要对参数进行清洗,以符合反射类
        $args = $this->bindParams($reflect, $vars);

        // 使用数组给方法传送参数,并执行。
        return $reflect->invokeArgs($instance, $args);
    }

    /**
     * 调用反射执行callable 支持参数绑定
     * @depreacate 星级:*****
     * @depreacate 作用:调度
     * @todo 感觉是执行回调
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:1 无上级调用但有下级子调用
     *
     * @access public
     * @param mixed $callable
     * @param array $vars       参数
     * @param bool  $accessible 设置是否可访问
     * @return mixed
     */
    public function invoke($callable, array $vars = [], bool $accessible = false)
    {
        // 核心部分
        if ($callable instanceof Closure) {
            // 如果是匿名方法
            return $this->invokeFunction($callable, $vars);
        } elseif (is_string($callable) && false === strpos($callable, '::')) {
            // 如果是函数
            return $this->invokeFunction($callable, $vars);
        } else {
            // 默认就是类的方法调用
            return $this->invokeMethod($callable, $vars, $accessible);
        }
    }

    /**
     * 调用反射执行类的实例化 支持依赖注入
     * @depreacate 星级:*****
     * @depreacate 作用:实现,逻辑
     * @todo 反射实现了委托模式的调用 感觉是执行回调
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:2 有上级调用也有下级调用
     *
     * @access public
     * @param string $class 类名
     * @param array  $vars  参数
     * @return mixed
     */
    public function invokeClass(string $class, array $vars = [])
    {
        // 因为类调用容易出现异常,因此加上异常捕获
        try {
            // 获取实例中指定的类,因为系统加载时已经注册了一部分对应的命名空间等内容
            // 使用反射类来获取系统注册过的类
            $reflect = new ReflectionClass($class);
        } catch (ReflectionException $e) {
            throw new ClassNotFoundException('class not exists: ' . $class, $class, $e);
        }

        // 判断指定的方法是否存在,框架内这个方法权重非常高.默认加载的.为什么要这么做?
        // 判断是否初始有指定魔术方法的类
        if ($reflect->hasMethod('__make')) {
            // 获取该方法属性
            $method = $reflect->getMethod('__make');
            if ($method->isPublic() && $method->isStatic()) {
                // 绑定参数?为什么要这样获取参数
                // 感觉是要对参数进行清洗,以符合反射类
                // 把传入的参数绑定到实例化对象上.
                $args = $this->bindParams($method, $vars);
                // 使用数组给方法传送参数,并执行。
                return $method->invokeArgs(null, $args);
            }
        }

        // 处理无指定魔术方法类

        // 获取已反射的类的构造函数
        $constructor = $reflect->getConstructor();

        // 有构造函数,绑定参数
        $args = $constructor ? $this->bindParams($constructor, $vars) : [];

        // 从给出的参数创建一个新的类实例
        // 创建一个类的新实例，给出的参数将传递到类的构造函数。
        $object = $reflect->newInstanceArgs($args);

        // 使用数组给方法传送参数,并执行
        $this->invokeAfter($class, $object);

        // 返回实例化后的对象
        return $object;
    }

    /**
     * 执行invokeClass回调
     * @depreacate 星级:*****
     * @depreacate 作用:实现,逻辑
     * @todo 执行调用反射执行类的实例化后的处理,在什么场景下起作用.怎么起作用的?
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:3 有上级调用但无下级调用
     *
     * @access protected
     * @param string $class  对象类名
     * @param object $object 容器对象实例
     * @return void
     */
    protected function invokeAfter(string $class, $object): void
    {
        // 判断容器回调是否存在 *
        if (isset($this->invokeCallback['*'])) {
            foreach ($this->invokeCallback['*'] as $callback) {
                $callback($object, $this);
            }
        }

        if (isset($this->invokeCallback[$class])) {
            foreach ($this->invokeCallback[$class] as $callback) {
                $callback($object, $this);
            }
        }
    }

    /**
     * 绑定参数
     * @depreacate 星级:****
     * @depreacate 作用:实现,逻辑,数据
     * @todo 绑定到哪去了?非常重要的实现,需要深入分析.把传入的参数重新封装再传出来.我没明白这么做的意义
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:2 有上级调用也有下级调用
     *
     * @access protected
     * @param ReflectionFunctionAbstract $reflect 反射类
     * @param array                      $vars    参数
     * @return array
     */
    protected function bindParams(ReflectionFunctionAbstract $reflect, array $vars = []): array
    {
        if ($reflect->getNumberOfParameters() == 0) {
            return [];
        }

        // 判断数组类型 数字数组时按顺序绑定参数
        reset($vars);
        // 从当前内部指针位置返回元素键名
        $type   = key($vars) === 0 ? 1 : 0;
        // 获取参数组
        $params = $reflect->getParameters();
        // 绑定参数
        $args   = [];

        // 对象方式操作
        foreach ($params as $param) {
            $name      = $param->getName();
            // 驼峰转下划线小写
            $lowerName = Str::snake($name);
            $class     = $param->getClass();

            if ($class) {
                // 如果是类,调用类的方法名和参数
                $args[] = $this->getObjectParam($class->getName(), $vars);
            } elseif (1 == $type && !empty($vars)) {
                // 参数存储,并且参数数组也不是空的
                // 将数组开头的单元移出数组
                // ?这是要做什么?
                $args[] = array_shift($vars);
            } elseif (0 == $type && array_key_exists($name, $vars)) {
                // 和下面判断一样,只是一个是判断是否有同名存在.下面是判断是否是驼峰名存在
                $args[] = $vars[$name];
            } elseif (0 == $type && array_key_exists($lowerName, $vars)) {
                $args[] = $vars[$lowerName];
            } elseif ($param->isDefaultValueAvailable()) {
                // 检查是否有默认值
                $args[] = $param->getDefaultValue();
            } else {
                // 因为是严格模式调用.因此需要加上对类型异常的捕获
                // 当参数不是预期的类型时，抛出 InvalidArgumentException
                throw new InvalidArgumentException('method param miss:' . $name);
            }
        }

        return $args;
    }

    /**
     * 创建工厂对象实例
     * @depreacate 星级:****
     * @depreacate 作用:实现,逻辑,数据
     * @todo 非常重要的实现,需要深入分析.把传入的参数重新封装再传出来.我没明白这么做的意义
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:1 无上级调用但有下级子调用
     *
     * @param string $name      工厂类名
     * @param string $namespace 默认命名空间
     * @param array  $args
     * @return mixed
     * @deprecated
     * @access public
     */
    public static function factory(string $name, string $namespace = '', ...$args)
    {
        $class = false !== strpos($name, '\\') ? $name : $namespace . ucwords($name);

        // 获取当前容器的实例（单例）后调用反射执行类的实例化
        return Container::getInstance()->invokeClass($class, $args);
    }

    /**
     * 获取对象类型的参数值
     * @depreacate 星级:
     * @depreacate 作用:实现,逻辑
     * @todo  需要深入分析下
     * @depreacate 原则:单一职责原则/里氏替换原则/依赖倒置原则/接口隔离原则/迪米特法则/开闭原则
     * @depreacate 调用级别:3 有上级调用但无下级调用
     *
     * @access protected
     * @param string $className 类名
     * @param array  $vars      参数
     * @return mixed
     */
    protected function getObjectParam(string $className, array &$vars)
    {
        $array = $vars;
        // 参数存储,并且参数数组也不是空的
        // 将数组开头的单元移出数组
        // ?这是要做什么?
        $value = array_shift($array);

        if ($value instanceof $className) {
            $result = $value;
            array_shift($vars);
        } else {
            // 创建类的实例 已经存在则直接获取
            $result = $this->make($className);
        }

        return $result;
    }

    /**
     * 魔术方法
     *
     * @access public
     * @param mixed $name
     * @param mixed $value
     * @return mixed
     */
    public function __set($name, $value)
    {
        $this->bind($name, $value);
    }

    /**
     * 魔术方法
     * @depreacate 调用级别:1
     *
     * @access public
     * @param mixed $name
     * @return mixed
     */
    public function __get($name)
    {
        return $this->get($name);
    }

    /**
     * 魔术方法
     *
     * @access public
     * @param mixed $name
     * @return bool
     */
    public function __isset($name): bool
    {
        return $this->exists($name);
    }

    /**
     * 魔术方法
     * @depreacate 调用级别:1
     *
     * @access public
     * @param mixed $name
     * @return bool
     */
    public function __unset($name)
    {
        $this->delete($name);
    }

    /**
     * 检查一个偏移位置是否存在
     * 继承ArrayAccess
     * @depreacate 调用级别:1
     */
    public function offsetExists($key)
    {
        return $this->exists($key);
    }

    /**
     * 获取一个偏移位置的值
     * 继承ArrayAccess
     */
    public function offsetGet($key)
    {
        return $this->make($key);
    }

    /**
     * 设置一个偏移位置的值
     * 继承ArrayAccess
     */
    public function offsetSet($key, $value)
    {
        $this->bind($key, $value);
    }

    /**
     * 复位一个偏移位置的值
     * 继承ArrayAccess
     */
    public function offsetUnset($key)
    {
        $this->delete($key);
    }


    /**
     * Countable
     * 获取实例化的数量
     * @depreacate 调用级别:0
     */
    public function count()
    {
        return count($this->instances);
    }


    /**
     * IteratorAggregate
     * 获取实例化的迭代器总量
     * @depreacate 调用级别:0
     */
    public function getIterator()
    {
        return new ArrayIterator($this->instances);
    }
}
